// ml:run = $bin < input
#include <iostream>
#include <unordered_map>

struct key { int x, y; };

struct key_hash
{
    std::size_t operator()(key const& k) const
    {
        return std::hash<int>()(k.x) ^
            (std::hash<int>()(k.y) << 4);
    }
};

struct key_equal
{
    bool operator()(key const& l, key const& r) const
    {
        return l.x == r.x && l.y == r.y;
    }
};

int const maxn = 256;
std::unordered_map<key, short, key_hash, key_equal> f[maxn];
int n, a, b;


void init()
{
    for (int i = 0; i <= n; i++) f[i].clear();
}

short dfs(int turn, int a, int b)
{
    if (turn == n) {
        return f[turn][{a, b}] = (a > b ? 1 : (a < b ? 0 : (turn & 1)));
    }
    if (f[turn].count({a, b})) return f[turn][{a, b}];
    short ans = 0;
    for (int i = 0; i <= a; i++) {
        short tmp = 300;
        short t1 = 0;
        if (i) t1 = dfs(turn + 1, a - i, b) + 1;
        else t1 = dfs(turn + 1, a - i, b) + (turn & 1);

        if (i) tmp = std::min(tmp, t1);
        else tmp = std::min(tmp, t1);

        if (turn & 1)
            if (b >= i + 1)
                tmp = std::min(tmp, dfs(turn + 1, a, b - i - 1));
        if (!(turn & 1)) {
            if (b >= i)
                tmp = std::min(tmp, dfs(turn + 1, a, b - i));
        }
        ans = std::max(ans, tmp);
    }
    return f[turn][{a, b}] = ans;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    int T; std::cin >> T;
    while (T--) {
        std::cin >> n >> a >> b;
        init();
        int ans = dfs(1, a, b);
        std::cout << "Alice " << ans << " Bob " << n - ans << "\n";
    }
}

